import java.util.*;
public class HasIncreasingSubarrays {
  public boolean hasIncreasingSubarrays(List<Integer> nums, int k) {
      int n = nums.size();
      if(n < 2 * k) {
          return false;
      }
      int dp[] = new int[n];
      Arrays.fill(dp, 1);
     for(int i = 1; i<n; i++){
        if(nums.get(i) > nums.get(i-1)){
          dp[i] = dp[i-1] + 1;
        }
     }
    for(int i = 0; i< n-k; i++){
      if(dp[i] >=k && dp[i+k]>=k){
        return true;
      }
    }
      return false;
  }

  public int maxIncreasingSubarrays(List<Integer> nums) {
    int n = nums.size();
    if(n < 2){
      return 0;
    }
    int dp[] = new int[n];
    Arrays.fill(dp, 1);
    for(int i = 1; i<n; i++){
      if(nums.get(i) > nums.get(i-1)){
        dp[i] = dp[i-1] + 1;
      }
    }
    int max = 1;
    for(int i = 0; i < n-1; i++){
      for(int k = max; k <= (n - i)/2; k++){
        if(dp[i] >= k && dp[i+k] >= k){
          max = Math.max(max, k);
        }
      }
    }
    return max;

    // class Solution {
    //     public int maxIncreasingSubarrays(List<Integer> nums) {
    //         int ans = 0;
    //         int preCnt = 0;
    //         int cnt = 0;
    //         for (int i = 0; i < nums.size(); i++) {
    //             cnt++;
    //             // i 是严格递增段的末尾
    //             if (i == nums.size() - 1 || nums.get(i) >= nums.get(i + 1)) {
    //                 ans = Math.max(ans, Math.max(cnt / 2, Math.min(preCnt, cnt)));
    //                 preCnt = cnt;
    //                 cnt = 0;
    //             }
    //         }
    //         return ans;
    //     }
    // }


  }

  public static void main(String[] args) {
      HasIncreasingSubarrays h = new HasIncreasingSubarrays();
      List<Integer> nums = new ArrayList<>();
      nums.add(2);
      nums.add(5);
      nums.add(7);
      nums.add(8);
      nums.add(9);
      nums.add(2);
      nums.add(3);
      nums.add(4);
      nums.add(3);
      nums.add(1);
      System.out.println(h.hasIncreasingSubarrays(nums, 3)); // true
      
  }
}

// 1、
// [2,5,7,8,9,2,3,4,3,1]
// 给你一个由 n 个整数组成的数组 nums 和一个整数 k，请你确定是否存在 两个 相邻 且长度为 k 的 严格递增 子数组。具体来说，需要检查是否存在从下标 a 和 b (a < b) 开始的 两个 子数组，并满足下述全部条件：

// 这两个子数组 nums[a..a + k - 1] 和 nums[b..b + k - 1] 都是 严格递增 的。
// 这两个子数组必须是 相邻的，即 b = a + k。
// 如果可以找到这样的 两个 子数组，请返回 true；否则返回 false。

// 子数组 是数组中的一个连续 非空 的元素序列。




// 2、
// 给你一个由 n 个整数组成的数组 nums ，请你找出 k 的 最大值，使得存在 两个 相邻 且长度为 k 的 严格递增 子数组。具体来说，需要检查是否存在从下标 a 和 b (a < b) 开始的 两个 子数组，并满足下述全部条件：

// 这两个子数组 nums[a..a + k - 1] 和 nums[b..b + k - 1] 都是 严格递增 的。
// 这两个子数组必须是 相邻的，即 b = a + k。
// 返回 k 的 最大可能 值。

// 子数组 是数组中的一个连续 非空 的元素序列。